const app = getApp();
import { get, post } from '../../../utils/request';
import auth from '../../../utils/auth';

// 性别映射
const genderMap = {
  'male': '男',
  'female': '女',
  'unknown': '未知'
};

Page({
  data: {
    serviceId: '',
    serviceDetail: null,
    loading: true,
    addressList: [],
    selectedAddress: null,
    dateList: [],
    selectedDate: '',
    timeList: [
      { id: 1, time: '08:00', available: true },
      { id: 2, time: '09:00', available: true },
      { id: 3, time: '10:00', available: true },
      { id: 4, time: '11:00', available: true },
      { id: 5, time: '13:00', available: true },
      { id: 6, time: '14:00', available: true },
      { id: 7, time: '15:00', available: true },
      { id: 8, time: '16:00', available: true },
      { id: 9, time: '17:00', available: true },
      { id: 10, time: '18:00', available: true }
    ],
    selectedTime: '',
    remark: '',
    totalPrice: 0,
    userType: 'user', // 默认为普通用户
    appointmentTime: '',
    submitLoading: false,

    // 服务人员相关
    needProvider: false, // 是否需要指定服务人员
    providers: [], //, 可用服务人员列表
    providersLoaded: false, // 服务人员是否已加载
    selectedProvider: null, // 已选服务人员
    defaultAvatarUrl: '/assets/images/default.png' // 修改默认头像路径
  },

  onLoad(options) {
    // 检查登录状态
    if (!auth.isLoggedIn()) {
      wx.showToast({
        title: '请先登录后再预约',
        icon: 'none'
      });
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/login/login'
        });
      }, 1000);
      return;
    }

    if (options.serviceId) {
      this.setData({
        serviceId: options.serviceId,
      });

      // 设置预约时间
      if (options.appointmentTime) {
        this.setData({
          appointmentTime: options.appointmentTime
        });
      }

      // 获取服务详情和地址列表
      this.getServiceDetail();
      this.getAddressList();
      this.generateDateList();
    } else {
      wx.showToast({
        title: '服务信息不存在',
        icon: 'none'
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
    }

    // 获取用户类型
    const userInfo = wx.getStorageSync('userInfo');
    const userType = userInfo && userInfo.role === 'provider' ? 'worker' : 'user';
    this.setData({ userType });

    // 如果是服务人员，则无法创建订单
    if (userType === 'worker') {
      wx.showToast({
        title: '服务人员无法创建订单',
        icon: 'none',
        duration: 2000
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 2000);
    }
  },

  // 页面显示时检查登录状态，用于从登录页返回时刷新数据
  onShow() {
    // 如果已经加载过服务详情，则不需要重新获取
    if (this.data.serviceDetail) {
      // 仅当登录成功后才重新获取地址列表
      if (this.checkLogin()) {
        this.getAddressList();
      }
    }

    // 检查是否有选择的地址
    const pages = getCurrentPages();
    const currPage = pages[pages.length - 1];

    // 如果有选择的地址，设置为当前选中地址
    if (currPage.data.selectedAddress) {
      this.setData({
        selectedAddress: currPage.data.selectedAddress
      });
    }
  },

  // 获取服务详情
  getServiceDetail() {
    const serviceId = this.data.serviceId;
    this.setData({ loading: true });

    // 调用真实接口获取服务详情
    get('/api/services/get/vo', { id: serviceId }).then(res => {
      if (res.code === 0 && res.data) {
        // 处理服务详情数据
        const serviceData = res.data;
        const serviceDetail = {
          id: serviceData.id,
          title: serviceData.name,
          description: serviceData.description || '暂无描述',
          price: serviceData.price,
          unit: '次',
          minHours: 1,
          coverImage: serviceData.image || '/assets/images/default.png',
          images: serviceData.image ? [serviceData.image] : ['/assets/images/default.png'],
          duration: serviceData.duration || 60
        };

        this.setData({
          serviceDetail,
          loading: false,
          totalPrice: serviceData.price
        });
      } else {
        wx.showToast({
          title: res.message || '获取服务详情失败',
          icon: 'none'
        });
        setTimeout(() => {
          wx.navigateBack();
        }, 1500);
      }
    }).catch(err => {
      console.error('获取服务详情失败', err);
      wx.showToast({
        title: '获取服务详情失败',
        icon: 'none'
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
    });
  },

  // 生成未来7天的日期列表
  generateDateList() {
    const dateList = [];
    const today = new Date();

    for (let i = 0; i < 7; i++) {
      const date = new Date(today);
      date.setDate(today.getDate() + i);

      const year = date.getFullYear();
      const month = date.getMonth() + 1;
      const day = date.getDate();
      const weekDay = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'][date.getDay()];

      dateList.push({
        date: `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')}`,
        display: `${month}月${day}日`,
        weekDay: weekDay
      });
    }

    this.setData({
      dateList,
      selectedDate: dateList[0].date
    });
  },

  // 获取地址列表
  getAddressList() {
    // 调用分页地址列表接口
    post('/api/address/my/list/page/vo', {
      current: 1,
      pageSize: 20,
      sortField: 'isDefault',
      sortOrder: 'desc'
    }).then(res => {
      if (res.code === 0 && res.data && res.data.records) {
        const addressList = res.data.records.map(item => ({
          id: item.id,
          name: item.contactName,
          phone: item.contactPhone,
          address: item.addressDetail,
          isDefault: item.isDefault === 1
        }));

        this.setData({ addressList });

        // 选中默认地址或第一个地址
        if (addressList.length > 0) {
          // 如果已经有选中的地址，则不更新
          if (!this.data.selectedAddress) {
            const defaultAddress = addressList.find(addr => addr.isDefault);
            this.setData({
              selectedAddress: defaultAddress || addressList[0]
            });
          }
        }
      }
    }).catch(err => {
      console.error('获取地址列表失败', err);
    });
  },

  // 选择地址
  selectAddress() {
    wx.navigateTo({
      url: '/pages/address/address?select=true'
    });
  },

  // 设置选中的地址
  setSelectedAddress(address) {
    if (address) {
      this.setData({
        selectedAddress: address
      });
    }
  },

  // 页面事件处理函数，接收从地址选择页面返回的事件
  onAddressSelect(address) {
    if (address && address.id) {
      this.setData({
        selectedAddress: address
      });
    }
  },

  // 选择日期
  selectDate(e) {
    const index = e.currentTarget.dataset.index;
    const date = this.data.dateList[index].date;
    this.setData({
      selectedDate: date,
      // 重置服务人员相关数据
      providersLoaded: false,
      providers: [],
      selectedProvider: null
    });

    // 如果需要指定服务人员，重新加载服务人员列表
    if (this.data.needProvider && this.data.selectedTime) {
      this.loadAvailableProviders();
    }
  },

  // 选择时间
  selectTime(e) {
    const id = e.currentTarget.dataset.id;
    const time = this.data.timeList.find(item => item.id === id).time;

    // 设置选中的时间
    this.setData({
      selectedTime: time,
      // 重置服务人员相关数据
      providersLoaded: false,
      providers: [],
      selectedProvider: null
    });

    // 如果需要指定服务人员，并且已经选择了日期，加载服务人员列表
    if (this.data.needProvider && this.data.selectedDate) {
      // 等待状态更新完成后再调用接口
      wx.nextTick(() => {
        this.loadAvailableProviders();
      });
    }
  },

  // 切换是否需要指定服务人员
  toggleNeedProvider(e) {
    const needProvider = e.detail.value;

    this.setData({
      needProvider,
      providersLoaded: false,
      providers: [],
      selectedProvider: null
    });

    // 如果需要指定服务人员，且已经选择了日期和时间，加载服务人员列表
    if (needProvider && this.data.selectedDate && this.data.selectedTime) {
      this.loadAvailableProviders();
    }
  },

  // 加载可用服务人员
  loadAvailableProviders() {
    if (!this.data.selectedDate || !this.data.selectedTime) {
      wx.showToast({
        title: '请先选择服务时间',
        icon: 'none'
      });
      return;
    }

    this.setData({
      providersLoaded: false
    });

    // 处理日期格式
    // 将日期字符串处理为Java Date接受的格式，例如 "yyyy/MM/dd"
    const dateParts = this.data.selectedDate.split('-');
    const formattedDate = `${dateParts[0]}/${dateParts[1]}/${dateParts[2]}`;

    // 调用接口获取可用服务人员
    get('/api/service-provider/available', {
      serviceId: this.data.serviceId,
      appointmentTime: formattedDate,
      duration: this.data.serviceDetail.duration
    }).then(res => {
      if (res.code === 0 && res.data) {
        // 处理服务人员数据，映射性别
        const processedProviders = res.data.map(provider => {
          return {
            ...provider,
            // 处理性别映射
            genderText: genderMap[provider.gender] || '未知'
            // 头像直接在wxml中处理
          };
        });

        this.setData({
          providers: processedProviders,
          providersLoaded: true
        });
      } else {
        this.setData({
          providers: [],
          providersLoaded: true
        });

        wx.showToast({
          title: res.message || '获取可用服务人员失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('获取可用服务人员失败', err);
      this.setData({
        providers: [],
        providersLoaded: true
      });

      wx.showToast({
        title: '获取可用服务人员失败',
        icon: 'none'
      });
    });
  },

  // 选择服务人员
  selectProvider(e) {
    const id = e.currentTarget.dataset.id;
    const provider = this.data.providers.find(item => item.id === id);

    if (provider) {
      this.setData({
        selectedProvider: provider
      });
    }
  },

  // 输入备注
  inputRemark(e) {
    this.setData({
      remark: e.detail.value
    });
  },

  // 创建订单
  createOrder() {
    if (!this.data.selectedAddress) {
      wx.showToast({
        title: '请选择服务地址',
        icon: 'none'
      });
      return;
    }

    if (!this.data.selectedDate) {
      wx.showToast({
        title: '请选择服务日期',
        icon: 'none'
      });
      return;
    }

    if (!this.data.selectedTime) {
      wx.showToast({
        title: '请选择服务时间',
        icon: 'none'
      });
      return;
    }

    // 如果需要指定服务人员，但未选择
    if (this.data.needProvider && !this.data.selectedProvider) {
      wx.showToast({
        title: '请选择服务人员',
        icon: 'none'
      });
      return;
    }

    // 防止重复提交
    if (this.data.submitLoading) {
      return;
    }

    this.setData({
      submitLoading: true
    });

    // 使用标准ISO格式处理日期时间（按照后端错误信息中的标准格式）
    // 使用格式 "yyyy-MM-dd'T'HH:mm:ss.SSS"
    const appointmentDate = this.data.selectedDate; // 已经是 yyyy-MM-dd 格式
    const appointmentTime = `${appointmentDate}T${this.data.selectedTime}:00.000`;

    // 构建订单数据
    const orderData = {
      serviceId: this.data.serviceId,
      addressId: this.data.selectedAddress.id,
      appointmentTime: appointmentTime,
      totalPrice: this.data.totalPrice
    };

    // 如果指定了服务人员，添加providerId
    if (this.data.needProvider && this.data.selectedProvider) {
      orderData.providerId = this.data.selectedProvider.id;
    }

    // 显示加载状态
    wx.showLoading({
      title: '提交中...',
      mask: true
    });

    // 调用创建订单接口
    post('/api/orders/add', orderData).then(res => {
      wx.hideLoading();

      if (res.code === 0) {
        wx.showToast({
          title: '订单创建成功',
          icon: 'success'
        });

        // 跳转到订单详情页
        setTimeout(() => {
          wx.redirectTo({
            url: `/pages/order/detail/detail?id=${res.data}`
          });
        }, 1500);
      } else {
        wx.showToast({
          title: res.message || '创建订单失败',
          icon: 'none'
        });
      }

      this.setData({
        submitLoading: false
      });
    }).catch(err => {
      wx.hideLoading();
      console.error('创建订单失败', err);
      wx.showToast({
        title: '创建订单失败',
        icon: 'none'
      });
      this.setData({
        submitLoading: false
      });
    });
  },

  // 检查是否登录
  checkLogin() {
    const token = wx.getStorageSync('token');
    if (!token) {
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 1500
      });

      // 跳转到登录页面
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/login/login'
        });
      }, 1500);
      return false;
    }
    return true;
  }
}); 